/**
 *====================================================
 * 文件名称: EnterpriseServiceImpl.java
 * 修订记录：
 * No    日期				作者(操作:具体内容)
 * 1.    2015年09月23日	chenxy(创建:创建文件)
 *====================================================
 * 类描述：(说明未实现或其它不应生成javadoc的内容)
 */
package com.yuexunit.finance.member.service;

import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;

import com.yuexunit.core.exception.NotFoundException;
import com.yuexunit.finance.common.util.BeanUtils;
import com.yuexunit.finance.member.entity.BankcodeEntity;
import com.yuexunit.finance.member.entity.EnterpriseEntity;
import com.yuexunit.finance.member.entity.EnterpriseModifyEntity;
import com.yuexunit.finance.member.entity.lexicon.AuditStateEnum;
import com.yuexunit.finance.member.entity.lexicon.EnterpriseTypeEnum;
import com.yuexunit.finance.member.entity.lexicon.StateEnum;
import com.yuexunit.finance.member.service.order.GBKOrder;
import com.yuexunit.finance.project.entity.FinanceAuditLogEntity;
import com.yuexunit.finance.project.entity.lexicon.DefaultAccountEnum;
import com.yuexunit.finance.zhanghuguangli.entity.EnterpriseAccountEntity;
import com.yuexunit.inject.annotation.Implements;
import com.yuexunit.page.PageCriteria;
import com.yuexunit.page.PageList;
import com.yuexunit.persist.PersistUtil;
import com.yuexunit.persist.annotation.Transactional;
import com.yuexunit.util.DateUtil;
import com.yuexunit.util.StringUtil;

/**
 * @ClassName: EnterpriseServiceImpl
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author chenxy
 * @date 2015年09月23日 18:55:49
 */
@Implements(EnterpriseService.class)
public class EnterpriseServiceImpl implements EnterpriseService {

	@Override
	@Transactional
	public Long createEnterprise(EnterpriseEntity entity) {
		entity.setState(StateEnum.VALID);
		entity.setAuditState(AuditStateEnum.UNKNOWN);
		entity.setEnabled(true);
		entity.setCreateDateTime(DateUtil.now());
		entity.setUpdateDateTime(DateUtil.now());
		entity.setForbidden(Boolean.FALSE);
		entity.setFreeze(Boolean.FALSE);
		System.out.println(entity.toString());
		PersistUtil.insert(entity);
		return entity.getEnterpriseId();
	}

	@Override
	@Transactional
	public void updateEnterprise(EnterpriseEntity entity) {
		EnterpriseEntity persist = inquireEnterpriseDetail(entity.getEnterpriseId());
		BeanUtils.copyProperties(entity, persist);
		persist.setUpdateDateTime(DateUtil.now());
		PersistUtil.update(persist);
	}
	
	@Override
	@Transactional
	public void updateAuthenticationEnterprise(EnterpriseModifyEntity entity) {
		EnterpriseModifyEntity persist = inquireEnterpriseDetails(entity.getAuthenticationId());
		BeanUtils.copyProperties(entity, persist);
		persist.setUpdateDateTime(DateUtil.now());
		PersistUtil.update(persist);
	}

	@Override
	@Transactional
	public void persistEnterprise(EnterpriseEntity persist) {
		System.out.println("LAT:" + persist.getLat());
		System.out.println("LNG:" + persist.getLng());
		persist.setUpdateDateTime(DateUtil.now());
		PersistUtil.update(persist);
	}
	
	@Override
	@Transactional
	public void persistAuthenticationEnterprise(EnterpriseModifyEntity persistence) {
		EnterpriseModifyEntity persist = queryEnterpriseDetail(persistence.getAuthenticationId());
		BeanUtils.copyProperties(persistence, persist);
		PersistUtil.update(persist);
	}

	@Override
	@Transactional
	public void disableEnterprise(Long enterpriseId) {
		EnterpriseEntity persist = PersistUtil.get(EnterpriseEntity.class, enterpriseId);
		persist.setEnabled(false);
		PersistUtil.update(persist);
	}

	@Override
	public EnterpriseEntity inquireEnterpriseDetail(Long enterpriseId) {
		EnterpriseEntity entity = PersistUtil.get(EnterpriseEntity.class, enterpriseId);
		if (entity == null || !entity.getEnabled()) {
			throw new NotFoundException("该企业不存在！");
		}
		return entity;
	}
	
	@Override
	public EnterpriseModifyEntity inquireEnterpriseDetails(Long authenticationId) {
		EnterpriseModifyEntity entity = PersistUtil.get(EnterpriseModifyEntity.class, authenticationId);
		if (entity == null) {
			throw new NotFoundException("该企业不存在！");
		}
		return entity;
	}
	
	@Override
	public EnterpriseAccountEntity inquireAccountManagements(Long accountId) {
		EnterpriseAccountEntity entity = PersistUtil.get(EnterpriseAccountEntity.class, accountId);
		if (entity == null) {
			throw new NotFoundException("该企业不存在！");
		}
		return entity;
	}
	
	@Override
	public EnterpriseModifyEntity queryEnterpriseDetail(Long authenticationId) {
		return  PersistUtil.get(EnterpriseModifyEntity.class, authenticationId);
	}
	
	@Override
	public EnterpriseEntity inquireEnterprise(Long enterpriseId) {
		return PersistUtil.get(EnterpriseEntity.class, enterpriseId);
	}
	
	@Override
	public List<FinanceAuditLogEntity> inquirePickUpGoodsAuditList(Long auditJoinId,Long auditState) {
		DetachedCriteria criteria = DetachedCriteria.forClass(FinanceAuditLogEntity.class);
		if(auditJoinId != null) {
			criteria.add(Restrictions.eq("auditJoinId", auditJoinId));	
			criteria.add(Restrictions.eq("auditState", auditState));
			criteria.addOrder(Order.desc("auditDate"));
		}
		return PersistUtil.get(criteria);
	}
	
	@Override
	public EnterpriseModifyEntity inquireAuthentication(Long authenticationId) {
		return PersistUtil.get(EnterpriseModifyEntity.class, authenticationId);
	}
	
	@Override
	public EnterpriseEntity inquireEnterpriseFromAccountId(Long accountId) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("accountId", accountId));
		List<EnterpriseEntity> list = PersistUtil.get(dc);
		if (list.size() <= 0) {
			throw new NotFoundException("该企业不存在！");
		}
		return list.get(0);
	}

	@Override
	public EnterpriseEntity inquireTenantEnterprise(Long tenantId, boolean ignore, Boolean enabled) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		if(enabled != null && enabled.booleanValue()) {
			dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		}
		dc.add(Restrictions.eq("tenantId", tenantId));
		List<EnterpriseEntity> list = PersistUtil.get(dc);
		if (list.size() > 1) {
			throw new NotFoundException("该帐号存在多个企业中！");
		}
		if (ignore && list.size() <= 0) {
			return null;
		}
		if (list.size() <= 0) {
			throw new NotFoundException("该企业不存在！");
		}
		return list.get(0);
	}
	
	@Override
	public EnterpriseModifyEntity inquireAuthenticationEnterprises(Long tenantId, boolean ignore, Boolean enabled) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseModifyEntity.class);
		if(enabled != null && enabled.booleanValue()) {
			dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		}
		dc.add(Restrictions.eq("tenantId", tenantId));
		List<EnterpriseModifyEntity> list = PersistUtil.get(dc);
		if (list.size() > 1) {
			throw new NotFoundException("该帐号存在多个企业中！");
		}
		if (ignore && list.size() <= 0) {
			return null;
		}
		if (list.size() <= 0) {
			throw new NotFoundException("该企业不存在！");
		}
		return list.get(0);
	}
	
	@Override	
	public EnterpriseModifyEntity inquireAuthenticationEnterprise(Long enterpriseId) {
		return PersistUtil.get(EnterpriseModifyEntity.class, enterpriseId);
	}
	
	@Override
	public PageList<EnterpriseEntity> inquireEnterprisePageList(List<Long> enterpriseIds, String enterpriseName, AuditStateEnum auditState, String mobile, String legalPerson, StateEnum state, Date createDateTimeBegin, Date createDateTimeEnd, EnterpriseTypeEnum enterpriseType, Boolean isPassed, Long finalState, PageCriteria page) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		if (StringUtil.isNotBlank(enterpriseName)) {
			dc.add(Restrictions.like("enterpriseName", "%" + enterpriseName + "%"));
		}
		if (StringUtil.isNotBlank(mobile)) {
			dc.add(Restrictions.like("mobile", "%" + mobile + "%"));
		}
		if (StringUtil.isNotBlank(legalPerson)) {
			dc.add(Restrictions.like("legalPerson", "%" + legalPerson + "%"));
		}
		if (state != StateEnum.UNKNOWN) {
			dc.add(Restrictions.eq("state", state));
		}
		if (createDateTimeBegin != null) {
			dc.add(Restrictions.ge("createDateTime", createDateTimeBegin));
		}
		if (createDateTimeEnd != null) {
			dc.add(Restrictions.le("createDateTime", createDateTimeEnd));
		}
		if (enterpriseType != null) {
			dc.add(Restrictions.eq("enterpriseType", enterpriseType));
		}
		if (finalState != null) {
			dc.add(Restrictions.eq("finalState", finalState));
		}
		if (enterpriseIds != null) {
			if (enterpriseIds.size() == 0) {
				enterpriseIds.add(0L);
			}
			dc.add(Restrictions.in("enterpriseId", enterpriseIds));
		}
		if (Boolean.TRUE == isPassed) {
			dc.add(Restrictions.in("auditState", new AuditStateEnum[]{AuditStateEnum.FINISH, AuditStateEnum.PASS}));
		} else if (auditState != AuditStateEnum.UNKNOWN) {
			dc.add(Restrictions.eq("auditState", auditState));
		}
		dc.addOrder(Order.desc("createDateTime"));
		return PersistUtil.get(dc, page);
	}
	
	/*@Override
	public BankcodeEntity queryBankCodeList(String dotName){
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		if (StringUtil.isNotBlank(dotName)) {
			dc.add(Restrictions.like("dotName", "%" + dotName + "%"));
		}
		List<BankcodeEntity> list = PersistUtil.get(dc);
		if (list != null && !list.isEmpty()) {
			return list.get(0);
		} else {
			return null;
		}
	}*/
	@Override
	public PageList<BankcodeEntity> queryBankCodeList(String dotName,PageCriteria page){
		DetachedCriteria dc = DetachedCriteria.forClass(BankcodeEntity.class);
		if (StringUtil.isNotBlank(dotName)) {
			dc.add(Restrictions.like("dotName", "%" + dotName + "%"));
		}
		return PersistUtil.get(dc, page);
	}
	
	@Override
	public PageList<EnterpriseModifyEntity> queryEnterpriseModifyPageList(String enterpriseName, AuditStateEnum auditState,String legalPerson, StateEnum state, Date createDateTimeBegin, Date createDateTimeEnd,EnterpriseTypeEnum enterpriseType, Boolean isPassed, PageCriteria page) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseModifyEntity.class);

		if (StringUtil.isNotBlank(enterpriseName)) {
			dc.add(Restrictions.like("enterpriseName", "%" + enterpriseName + "%"));
		}
		if (StringUtil.isNotBlank(legalPerson)) {
			dc.add(Restrictions.like("legalPerson", "%" + legalPerson + "%"));
		}
		if (state != StateEnum.UNKNOWN) {
			dc.add(Restrictions.eq("state", state));
		}
		if (createDateTimeBegin != null) {
			dc.add(Restrictions.ge("createDateTime", createDateTimeBegin));
		}
		if (createDateTimeEnd != null) {
			dc.add(Restrictions.le("createDateTime", createDateTimeEnd));
		}
		if (enterpriseType != null) {
			dc.add(Restrictions.eq("enterpriseType", enterpriseType));
		}
		if (Boolean.TRUE == isPassed) {
			dc.add(Restrictions.in("auditState", new AuditStateEnum[]{AuditStateEnum.FINISH, AuditStateEnum.PASS}));
		} else if (auditState != AuditStateEnum.UNKNOWN) {
			dc.add(Restrictions.eq("auditState", auditState));
		}
		dc.addOrder(Order.desc("createDateTime"));
		return PersistUtil.get(dc, page);
	}
	@Override
	public PageList<EnterpriseAccountEntity> queryAccountManagesPageList(String accountHolder,String depositBank, Date createDateTimeBegin, Date createDateTimeEnd, String subbranch, String creditCard,
			 Integer defaultAccount, Long enterpriseId, PageCriteria page) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseAccountEntity.class);
		if(enterpriseId !=null){
			dc.add(Restrictions.eq("enterpriseId", enterpriseId));
		}
		if (StringUtil.isNotBlank(accountHolder)) {
			dc.add(Restrictions.like("accountHolder", "%" + accountHolder + "%"));
		}
		if (StringUtil.isNotBlank(depositBank)) {
			dc.add(Restrictions.like("depositBank", "%" + depositBank + "%"));
		}
		if (createDateTimeBegin != null) {
			dc.add(Restrictions.le("createDateTime", createDateTimeBegin));
		}
		if (createDateTimeEnd != null) {
			dc.add(Restrictions.ge("createDateTime", createDateTimeEnd));
		}
		if (StringUtil.isNotBlank(subbranch)) {
			dc.add(Restrictions.like("subbranch", "%" + subbranch + "%"));
		}
		if (StringUtil.isNotBlank(depositBank)) {
			dc.add(Restrictions.like("creditCard", "%" + creditCard + "%"));
		}
		if (defaultAccount !=null && defaultAccount !=0) {
			dc.add(Restrictions.ge("defaultAccount", DefaultAccountEnum.valueOf(defaultAccount)));
		}
		dc.addOrder(Order.desc("top"));
		return PersistUtil.get(dc, page);
	}
	
	@Override
	public EnterpriseAccountEntity queryAccountInfoDetail(Long accountId) {
		return PersistUtil.get(EnterpriseAccountEntity.class, accountId);
	}
	@Override
	@Transactional
	public void updateAccountInfos(EnterpriseAccountEntity entity) {
		entity.setUpdateDateTime(DateUtil.now());
		PersistUtil.update(entity);
	}
	
	@Override
	public PageList<EnterpriseModifyEntity> queryEnterpriseModifyPageLists(String enterpriseName, AuditStateEnum auditState,String legalPerson, Long enterpriseId, Date createDateTimeBegin, Date createDateTimeEnd,EnterpriseTypeEnum enterpriseType, Boolean isPassed, PageCriteria page) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseModifyEntity.class);
//		if (StringUtil.isNotBlank(enterpriseName)) {
//			dc.add(Restrictions.like("enterpriseName", "%" + enterpriseName + "%"));
//		}
//		if (StringUtil.isNotBlank(legalPerson)) {
//			dc.add(Restrictions.like("legalPerson", "%" + legalPerson + "%"));
//		}
		if (enterpriseId !=null) {
			dc.add(Restrictions.eq("enterpriseId", enterpriseId));
		}
//		if (createDateTimeBegin != null) {
//			dc.add(Restrictions.ge("createDateTime", createDateTimeBegin));
//		}
//		if (createDateTimeEnd != null) {
//			dc.add(Restrictions.le("createDateTime", createDateTimeEnd));
//		}
//		if (enterpriseType != null) {
//			dc.add(Restrictions.eq("enterpriseType", enterpriseType));
//		}
//		if (enterpriseId !=null) {
//			dc.add(Restrictions.in("auditState", new AuditStateEnum[]{AuditStateEnum.FINISH, AuditStateEnum.PASS}));
//		} else if (auditState != AuditStateEnum.UNKNOWN) {
//			dc.add(Restrictions.eq("auditState", auditState));
//		}
//		dc.addOrder(Order.desc("createDateTime"));
		return PersistUtil.get(dc, page);
	}
	@Override
	public PageList<EnterpriseEntity> inquireEnterprisePageListByIds(Long[] enterpriseIds, PageCriteria page) {
		if (enterpriseIds == null || enterpriseIds.length <= 0) {
			return null;
		}
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.in("enterpriseId", enterpriseIds));
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		dc.add(Restrictions.in("auditState", new AuditStateEnum[]{AuditStateEnum.FINISH, AuditStateEnum.PASS}));
		dc.add(Restrictions.eq("enterpriseType", EnterpriseTypeEnum.DISTRIBUTORS));
		dc.addOrder(Order.desc("createDateTime"));
		return PersistUtil.get(dc, page);
	}

	@Override
	public PageList<EnterpriseEntity> inquireEnterprisePageList(String enterpriseName, AuditStateEnum auditState, String mobile, String legalPerson, StateEnum state, Date createDateTimeBegin, Date createDateTimeEnd, EnterpriseTypeEnum enterpriseType, String belongsEnterpriseCode, Long[] enterpriseId, PageCriteria page) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		dc.add(Restrictions.eq("belongsEnterpriseCode", belongsEnterpriseCode));
		if (StringUtil.isNotBlank(enterpriseName)) {
			dc.add(Restrictions.like("enterpriseName", "%" + enterpriseName + "%"));
		}
		if (auditState != AuditStateEnum.UNKNOWN) {
			dc.add(Restrictions.eq("auditState", auditState));
		}
		if (enterpriseId != null && enterpriseId.length != 0) {
			dc.add(Restrictions.in("enterpriseId", enterpriseId));
		}
		if (StringUtil.isNotBlank(mobile)) {
			dc.add(Restrictions.like("mobile", "%" + mobile + "%"));
		}
		if (StringUtil.isNotBlank(legalPerson)) {
			dc.add(Restrictions.like("legalPerson", "%" + legalPerson + "%"));
		}
		if (state != StateEnum.UNKNOWN) {
			dc.add(Restrictions.eq("state", state));
		}
		if (createDateTimeBegin != null) {
			dc.add(Restrictions.ge("createDateTime", createDateTimeBegin));
		}
		if (createDateTimeEnd != null) {
			dc.add(Restrictions.le("createDateTime", createDateTimeEnd));
		}
		if (enterpriseType != null) {
			dc.add(Restrictions.eq("enterpriseType", enterpriseType));
		}
		dc.addOrder(Order.desc("createDateTime"));
		return PersistUtil.get(dc, page);
	}
	
	@Override
	public List<Long> conutEnterpriseId(String enterpriseCode) {
		DetachedCriteria criteria = DetachedCriteria.forClass(EnterpriseEntity.class);
		criteria.add(Restrictions.eq("belongsEnterpriseCode", enterpriseCode));
		criteria.setProjection(Projections.projectionList().add(Projections.groupProperty("enterpriseId")));
		return PersistUtil.get(criteria);
	}

	@Override
	public List<Long> conutDistributors() {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		dc.add(Restrictions.eq("auditState", AuditStateEnum.UNAUDIT));
		dc.add(Restrictions.eq("enterpriseType", EnterpriseTypeEnum.DISTRIBUTORS));
		dc.setProjection(Projections.projectionList().add(Projections.groupProperty("enterpriseId")));
		return PersistUtil.get(dc);
	}

	@Override
	public List<Long> countEnterprises() {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		dc.add(Restrictions.eq("auditState", AuditStateEnum.UNAUDIT));
		dc.add(Restrictions.eq("enterpriseType", EnterpriseTypeEnum.CUSTOMER));
		dc.setProjection(Projections.projectionList().add(Projections.groupProperty("enterpriseId")));
		return PersistUtil.get(dc);
	}

	@Override
	public List<Long> countAuditedEnterprises() {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		dc.add(Restrictions.eq("auditState", AuditStateEnum.PASS));
		dc.add(Restrictions.eq("enterpriseType", EnterpriseTypeEnum.CUSTOMER));
		dc.setProjection(Projections.projectionList().add(Projections.groupProperty("enterpriseId")));
		return PersistUtil.get(dc);
	}
	
		@Override
	public List<Long> countAuditedClients() {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		dc.add(Restrictions.in("auditState", new AuditStateEnum[]{AuditStateEnum.PASS, AuditStateEnum.FINISH}));
		dc.setProjection(Projections.projectionList().add(Projections.groupProperty("enterpriseId")));
		return PersistUtil.get(dc);
	}

	@Override
	public List<EnterpriseEntity> inquireEnterpriseList(EnterpriseTypeEnum enterpriseType) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
		if (enterpriseType != null) {
			if (EnterpriseTypeEnum.CUSTOMER == enterpriseType) {
				dc.add(Restrictions.eqOrIsNull("enterpriseType", enterpriseType));
			} else {
				dc.add(Restrictions.eq("enterpriseType", enterpriseType));
			}
		}
		dc.add(Restrictions.in("auditState", new AuditStateEnum[]{AuditStateEnum.PASS, AuditStateEnum.FINISH}));
		dc.addOrder(GBKOrder.asc("enterpriseName"));
		return PersistUtil.get(dc);
	}
	
	@Override
	public List<EnterpriseEntity> inquireEnterpriseList1(Long enterpriseId) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enterpriseId", enterpriseId));
		return PersistUtil.get(dc);
	}
	
	@Override
	public List<EnterpriseEntity> inquireAllEnterpriseList() {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		return PersistUtil.get(dc);
	}

	@Override
	public List<EnterpriseEntity> inquireAuditedEnterpriseList() {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("enabled", Boolean.TRUE));
//		dc.add(Restrictions.in("auditState", new AuditStateEnum[]{AuditStateEnum.PASS, AuditStateEnum.FINISH}));
		return PersistUtil.get(dc);
	}

	@Override
	public EnterpriseEntity inquireEnterpriseByServiceId(String serviceId) {
		DetachedCriteria dc = DetachedCriteria.forClass(EnterpriseEntity.class);
		dc.add(Restrictions.eq("serviceId", serviceId));
		List<EnterpriseEntity> list = PersistUtil.get(dc);
		if (list != null && !list.isEmpty()) {
			return list.get(0);
		} else {
			return null;
		}
	}

	@Override
	public List<EnterpriseEntity> inquireEnterpriseByEnterpriseName(
			String enterpriseName) {
		DetachedCriteria criteria = DetachedCriteria.forClass(EnterpriseEntity.class);
		if(StringUtils.isNotBlank(enterpriseName)) {
			criteria.add(Restrictions.eq("enterpriseName", enterpriseName));
		}
		return PersistUtil.get(criteria);
	}
}
